package com.seeyon.ctp.rest.resources;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.seeyon.apps.brwh.kit.FormCap4Kit;
import com.seeyon.apps.brwh.kit.StrKit;
import com.seeyon.apps.kanban.enums.FileTableEnum;
import com.seeyon.apps.kanban.manager.IpdKanBanDataManager;
import com.seeyon.cap4.form.bean.*;
import com.seeyon.cap4.form.service.CAP4FormManager;
import com.seeyon.cap4.template.manager.CAPDataListSqlHelpManager;
import com.seeyon.ctp.common.AppContext;
import com.seeyon.ctp.common.ctpenumnew.manager.EnumManager;
import com.seeyon.ctp.common.exceptions.BusinessException;
import com.seeyon.ctp.common.log.CtpLogFactory;
import com.seeyon.ctp.common.po.ctpenumnew.CtpEnumItem;
import org.apache.commons.logging.Log;

import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.sql.SQLException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;


@Path("/jssdk")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class KanBanDataIPDResourcces extends BaseResource {

    private static final Log log = CtpLogFactory.getLog(KanBanDataIPDResourcces.class);

    private static EnumManager enumManager = (EnumManager) AppContext.getBean("enumManagerNew");
    private IpdKanBanDataManager ipdKanBanDataManager = (IpdKanBanDataManager) AppContext.getBean("ipdKanBanDataManager");
    private CAP4FormManager cap4FormManager = (CAP4FormManager) AppContext.getBean("cap4FormManager");
    private CAPDataListSqlHelpManager capDataListSqlHelpManager = (CAPDataListSqlHelpManager) AppContext.getBean("capDataListSqlHelpManager");

    /**
     * 通过POST请求获取中标率数据。
     *
     * @param param 包含请求所需参数的Map对象。
     * @return 包含中标率数据和状态码的Response对象。
     * @throws Exception 如果发生错误，则抛出异常。
     */
    @POST
    @Path("ipd/shangshi/project/bidAcceptanceProbability")
    public Response ipdShangShiZhongBiaoLvData(Map<String, Object> param) throws Exception {
        /* 初始化结果映射表 */
        Map<String, Object> resultMap = new HashMap<String, Object>();
        try {
            /* 从系统属性中获取配置信息 */
            String xmdaFormCode = AppContext.getSystemProperty("kanban.xmdaFormCode");
            String projectLevel = AppContext.getSystemProperty("kanban.projectLevel");
            String projectStatus = AppContext.getSystemProperty("kanban.projectStatus");
            String currentStage = AppContext.getSystemProperty("kanban.currentStage");
            String projectName = AppContext.getSystemProperty("kanban.projectName");
            String sfzb = AppContext.getSystemProperty("kanban.sfzb");
            String ydsj="ydsj";

            /* 根据表单代码获取表单bean */
            FormBean formBean = cap4FormManager.getFormByFormCode(xmdaFormCode);
            List<FormFieldBean> formFieldBeans = formBean.getMasterTableBean().getFields();
            StringBuilder stb = new StringBuilder();
            stb.append("select id, ");
            String xmxjFieldName = "";
            String xmztFieldName = "";
            String dqjdFieldName = "";
            String xmmcFieldName = "";
            String sfzbFieldName = "";
            String ydsjFieldName = "";
            /* 遍历表单字段，构建SQL查询语句，并获取相关字段名称 */
            for (FormFieldBean formFieldBean : formFieldBeans) {
                String fieldDesc = StrKit.str(formFieldBean.getDesc().trim());
                if (projectLevel.equals(fieldDesc)) {
                    xmxjFieldName = formFieldBean.getName();
                }
                if (projectStatus.equals(fieldDesc)) {
                    xmztFieldName = formFieldBean.getName();
                }
                if (currentStage.equals(fieldDesc)) {
                    dqjdFieldName = formFieldBean.getName();
                }
                if (projectName.equals(fieldDesc)) {
                    xmmcFieldName = formFieldBean.getName();
                }
                if (sfzb.equals(fieldDesc)) {
                    sfzbFieldName = formFieldBean.getName();
                }
                if (ydsj.equals(fieldDesc)){
                    ydsjFieldName = formFieldBean.getName();
                }
                if (!"".equals(fieldDesc)) {
                    String fieldName = formFieldBean.getName();
                    stb.append(fieldName).append(",");
                }
            }
            /* 删除最后一个逗号，完成SQL查询语句的构建 */
            String str = stb.substring(0, stb.length() - 1);
            String tableName = formBean.getMasterTableBean().getTableName();
            String newStr = str + " from " + tableName;
            log.info("中标率sql语句：" + newStr);
            /* 执行SQL查询 */
            List dataList = capDataListSqlHelpManager.selectDataList(newStr, null);
            /* 处理查询结果，统计各类项目的数量 */
            if (!dataList.isEmpty()) {
                List<Map<String, Object>> ssDataList = new ArrayList<Map<String, Object>>();
                List<Map<String, Object>> fssDataList = new ArrayList<Map<String, Object>>();
                int ssydNum = 0;
                int ssgzNum = 0;
                int ssjxzNum = 0;
                int fssydNum = 0;
                int fssgzNum = 0;
                int fssjxzNum = 0;
                int sssdNum = 0;
                int fsssdNum = 0;
                int fssydCount=0;
                for (int i = 0; i < dataList.size(); i++) {
                    Map<String, Object> dataMap = (Map<String, Object>) dataList.get(i);
                    Map<String, Object> tempDataMap = new HashMap<String, Object>();
                    String id = StrKit.str(dataMap.get("id"));
                    String url = "/seeyon/cap4/businessTemplateController.do?method=formContent&type=browse&rightId=-6498463788701760512.-7013542437671124890&moduleId=" + id + "&moduleType=42";
                    tempDataMap.put("url", url);
                    tempDataMap.put("projectName", dataMap.get(xmmcFieldName));
                    String xmxj = StrKit.str(dataMap.get(xmxjFieldName));
                    String xmxjEnumItemCode = "";
                    /* 根据项目星级获取枚举项代码和显示值 */
                    if (!"".equals(xmxj)) {
                        CtpEnumItem ctpEnumItem = enumManager.getCtpEnumItem(Long.parseLong(xmxj));
                        xmxjEnumItemCode = ctpEnumItem.getEnumItemCode();
                        tempDataMap.put("projectLevel", ctpEnumItem.getShowvalue());
                    } else {
                        tempDataMap.put("projectLevel", "");
                    }
                    String sfzbValue = StrKit.str(dataMap.get(sfzbFieldName));
                    CtpEnumItem sfzbEnumItem = null;
                    if (!"".equals(sfzbValue)) {
                        sfzbEnumItem = enumManager.getCtpEnumItem(Long.parseLong(sfzbValue));
                    }
                    String xmzt = StrKit.str(dataMap.get(xmztFieldName));
                    String xmztEnumItemCode = "";
                    /* 根据项目状态获取枚举项代码和显示值 */
                    if (!"".equals(xmzt)) {
                        CtpEnumItem ctpEnumItem = enumManager.getCtpEnumItem(Long.parseLong(xmzt));
                        xmztEnumItemCode = ctpEnumItem.getEnumItemCode();
                        tempDataMap.put("projectStatus", ctpEnumItem.getShowvalue());
                    } else {
                        tempDataMap.put("projectStatus", "");
                    }
                    String dqjd = StrKit.str(dataMap.get(dqjdFieldName));
                    String dqjdEnumItemCode = "";
                    /* 根据当前阶段获取枚举项代码和显示值 */
                    if (!"".equals(dqjd)) {
                        CtpEnumItem ctpEnumItem = enumManager.getCtpEnumItem(Long.parseLong(dqjd));
                        dqjdEnumItemCode = ctpEnumItem.getEnumItemCode();
                        tempDataMap.put("dqjd", ctpEnumItem.getShowvalue());
                    } else {
                        tempDataMap.put("dqjd", "");
                    }

                    String sfzbShowValue = "";
                    if (sfzbEnumItem != null) {
                        sfzbShowValue = sfzbEnumItem.getShowvalue();
                    }
                    /* 根据项目类型（双十项目或非双十项目）进行数据分类统计 */
                    if ("lx4_3".equals(xmxjEnumItemCode) || "lx5_3".equals(xmxjEnumItemCode)) {
                        ssDataList.add(tempDataMap);
                        if (!"XMZT_QXHFQ".equals(xmztEnumItemCode) && "YD".equals(dqjdEnumItemCode)) {
                            ssydNum += 1;
                        }
                        if (!"XMZT_QXHFQ".equals(xmztEnumItemCode) && "SD".equals(dqjdEnumItemCode)) {
                            sssdNum += 1;
                        }
                        if ("XMZT_QXHFQ".equals(xmztEnumItemCode)) {
                            ssgzNum += 1;
                        }
                        if ("XMZT_JXZ".equals(xmztEnumItemCode)&& (!"YD".equals(dqjdEnumItemCode)&&!"SD".equals(dqjdEnumItemCode)&&!"CJ".equals(dqjdEnumItemCode))) {
                            ssjxzNum += 1;
                        }
                    } else {
                        fssDataList.add(tempDataMap);
                        if (!"XMZT_QXHFQ".equals(xmztEnumItemCode) && "YD".equals(dqjdEnumItemCode)) {
                            fssydCount += 1;
                            if (dataMap.get(ydsjFieldName)==null||dataMap.get(ydsjFieldName)==""){
                                continue;
                            }else{
                                // 获取当前年份
                                int currentYear = LocalDate.now().getYear();
                                // 从dataMap中获取日期字符串
                                String dateStr = dataMap.get(ydsjFieldName).toString();
                                // 定义日期格式
                                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss.S");
                                // 解析日期字符串为LocalDate对象
                                LocalDate date = LocalDate.parse(dateStr, formatter);
                                // 比较年份
                                boolean isCurrentYear = date.getYear() == currentYear;
                                if (isCurrentYear){
                                    fssydNum += 1;
                                }
                            }
                        }
                        if (!"XMZT_QXHFQ".equals(xmztEnumItemCode) && "SD".equals(dqjdEnumItemCode)) {
                            fsssdNum += 1;
                        }
                        if ("XMZT_QXHFQ".equals(xmztEnumItemCode)) {
                            fssgzNum += 1;
                        }
                        if ("XMZT_JXZ".equals(xmztEnumItemCode)&& (!"YD".equals(dqjdEnumItemCode)&&!"SD".equals(dqjdEnumItemCode)&&!"CJ".equals(dqjdEnumItemCode))) {
                            fssjxzNum += 1;
                        }
                    }
                }
              //双十
              String ssxm_ydsl = AppContext.getSystemProperty("kanban.ssxm_ydsl");
              String ssxm_sdsl = AppContext.getSystemProperty("kanban.ssxm_sdsl");
              String ssxm_gzsl = AppContext.getSystemProperty("kanban.ssxm_gzsl");
              String ssxm_jxsl = AppContext.getSystemProperty("kanban.ssxm_jxsl");
              //非双十
              String fssxm_ydsl = AppContext.getSystemProperty("kanban.fssxm_ydsl");
              String fssxm_sdsl = AppContext.getSystemProperty("kanban.fssxm_sdsl");
              String fssxm_gzsl = AppContext.getSystemProperty("kanban.fssxm_gzsl");
              String fssxm_jxsl = AppContext.getSystemProperty("kanban.fssxm_jxsl");
              /* 计算并构建双十项目和非双十项目的中标率数据 */
              /* 双十数据 */
              Map<String, Object> ssdataMap = new HashMap<String, Object>();
              /* 赢单 */
              Map<String, Object> ssydMap = new HashMap<String, Object>();
              ssydMap.put("num", ssydNum);
              ssydMap.put("url", FormCap4Kit.getBbAddres(ssxm_ydsl));
              ssdataMap.put("yd", ssydMap);
              /* 输单 */
              Map<String, Object> sssdMap = new HashMap<String, Object>();
              sssdMap.put("num", sssdNum);
              sssdMap.put("url", FormCap4Kit.getBbAddres(ssxm_sdsl));
              ssdataMap.put("sd", sssdMap);
              /* 搁置 */
              Map<String, Object> ssgzMap = new HashMap<String, Object>();
              ssgzMap.put("num", ssgzNum);
              ssgzMap.put("url", FormCap4Kit.getBbAddres(ssxm_gzsl));
              ssdataMap.put("gz", ssgzMap);
              /* 进行中 */
              Map<String, Object> ssjxzMap = new HashMap<String, Object>();
              ssjxzMap.put("num", ssjxzNum);
              ssjxzMap.put("url", FormCap4Kit.getBbAddres(ssxm_jxsl));
              ssdataMap.put("jxz", ssjxzMap);
              int ssNum = ssDataList.size();
              double ssPercentage = (double) (ssydNum * 100) / ssNum;
              int sszbl = (int) Math.round(ssPercentage);
              ssdataMap.put("zbl", sszbl);
              ssdataMap.put("ssDataList", ssDataList);

              /* 非双十 */
              Map<String, Object> fssdataMap = new HashMap<String, Object>();
              /* 赢单 */
              Map<String, Object> fssydMap = new HashMap<String, Object>();
              fssydMap.put("num", fssydNum);
              fssydMap.put("url", FormCap4Kit.getBbAddres(fssxm_ydsl));
              fssdataMap.put("yd", fssydMap);
              /* 输单 */
              Map<String, Object> fsssdMap = new HashMap<String, Object>();
              fsssdMap.put("num", fsssdNum);
              fsssdMap.put("url", FormCap4Kit.getBbAddres(fssxm_sdsl));
              fssdataMap.put("sd", fsssdMap);
              /* 搁置 */
              Map<String, Object> fssgzMap = new HashMap<String, Object>();
              fssgzMap.put("num", fssgzNum);
              fssgzMap.put("url", FormCap4Kit.getBbAddres(fssxm_gzsl));
              fssdataMap.put("gz", fssgzMap);
              Map<String, Object> fssjxzMap = new HashMap<String, Object>();
              fssjxzMap.put("num", fssjxzNum);
              fssjxzMap.put("url", FormCap4Kit.getBbAddres(fssxm_jxsl));
              fssdataMap.put("jxz", fssjxzMap);
              int fssNum = fssDataList.size();
              double fssPercentage = (double) (fssydCount * 100) / fssNum;
              int fsszbl = (int) Math.round(fssPercentage);
              fssdataMap.put("zbl", fsszbl);
              fssdataMap.put("fssDataList", fssDataList);

                Map<String, Object> resultDataMap = new HashMap<String, Object>();
                resultDataMap.put("ssdata", ssdataMap);
                resultDataMap.put("fssdata", fssdataMap);
                resultMap.put("data", resultDataMap);
            }
            /* 设置结果状态码和消息 */
            resultMap.put("code", 200);
            resultMap.put("msg", "");

            return ok(JSON.toJSONString(resultMap));
        } catch (Exception e) {
            /* 记录错误日志，并返回错误信息 */
            log.error("获取双十项目中标率数据错误:", e);
            resultMap.put("code", 500);
            resultMap.put("msg", e.getMessage());
            resultMap.put("data", "");
            return ok(JSON.toJSONString(resultMap));
        }
    }


    /**
     * 接收并处理推品、设计、打样、制标管理模块的数据请求。
     * 该方法主要用于根据不同的里程碑类型查询相应的数据统计，包括总需求数、总未完成数、推品计划数、推品评审数。
     *
     * @param param 包含请求参数的Map对象，其中可能包含类型(type)等信息。
     * @return 返回一个包含查询结果的Response对象。
     * @throws Exception 如果查询过程中出现异常。
     */
    @POST
    @Path("ipd/manage/data")
    public Response ipdManageData(Map<String, Object> param) throws Exception {
        // 初始化结果映射，用于组装最终的返回数据
        Map<String, Object> result = new HashMap<String, Object>();
        Map<String, Object> resultDataMap = new HashMap<String, Object>();
        try {
            // 日志记录请求参数
            log.info("管理模块前端入参:" + JSON.toJSONString(param));
            // 从请求参数中提取类型信息
            JSONObject jsonObject = new JSONObject(param);
            String type = "";
            if (jsonObject.containsKey("type")) {
                type = StrKit.str(jsonObject.get("type"));
            }
            // 根据类型查询对应的枚举项，用于后续的查询条件构建
            CtpEnumItem ctpEnumItem = ipdKanBanDataManager.getEnumByCode(type);
            if (ctpEnumItem == null) {
                // 如果枚举项不存在，则返回错误信息
                result.put("code", 500);
                result.put("data", "");
                result.put("msg", "里程碑类型编码有误或未维护!");
                return ok(JSON.toJSONString(result));
            }
            // 获取《研发项目档案》表单编号
            String yfxmda_formCode = AppContext.getSystemProperty("kanban.yfxmda_formCode");
            // 根据编码获取表单
            FormBean yfxmda_formBean = cap4FormManager.getFormByFormCode(yfxmda_formCode);
            //表单字段
            List<FormFieldBean> yfxmda_fieldBeans = yfxmda_formBean.getAllFieldBeans();
            // 从系统属性中获取里程碑类型和状态的标识，用于查询条件构建
            /*里程碑*/
            String lcbType = AppContext.getSystemProperty("kanban.lcbType");
            /*里程碑状态(计划状态)*/
            String lcbStatus = AppContext.getSystemProperty("kanban.lcbStatus");
            /*计划开始时间*/
            String jhks_dateTime = AppContext.getSystemProperty("kanban.jhks_dateTime");
            /*实际完成时间*/
            String subSjwcDateTime = AppContext.getSystemProperty("kanban.subSjwcDateTime");
            //是否里程碑字段描述
            String isLcb = AppContext.getSystemProperty("kanban.lcb_sf");
            //研发项目档案主表-开发状态
            String kf_status = "mx_kfxmzt";
            //是否里程碑是
            String sfS = AppContext.getSystemProperty("kanban.sfS");
            CtpEnumItem qxEnum_sfS = FormCap4Kit.getEnumByCode(sfS);

            // 初始化各种统计数字
            int sumNumber = 0;
            //未完成(不等于已完成)
            int wwcSum = 0;
            //方案输出(不等于ptd评审和不等于已完成)
            int fascSum = 0;
            //推品评审(等于ptd评审)
            int tppsSum = 0;
            //平均时长
            long pjsc = 0;


            // 初始化用于构建SQL查询的变量
            String tableName = "";
            String lcbFieldName = "";
            String lcbztFieldName = "";
            String jhks_dateTimeFieldName = "";
            String subSjwcDateTimeFieldName = "";
            String isLcbFieldName = "";
            String kf_statusFieldName = "";
            for (FormFieldBean formFieldBean : yfxmda_fieldBeans) {
                String fieldDesc = StrKit.str(formFieldBean.getDesc().trim());
                if (lcbType.equals(fieldDesc)) {
                    lcbFieldName = formFieldBean.getName();
                    tableName = formFieldBean.getOwnerTableName();
                }
                if (lcbStatus.equals(fieldDesc)) {
                    lcbztFieldName = formFieldBean.getName();
                }
                if (jhks_dateTime.equals(fieldDesc)) {
                    jhks_dateTimeFieldName = formFieldBean.getName();
                }
                if (subSjwcDateTime.equals(fieldDesc)) {
                    subSjwcDateTimeFieldName = formFieldBean.getName();
                }
                if (isLcb.equals(fieldDesc)) {
                    isLcbFieldName = formFieldBean.getName();
                }
                if (kf_status.equals(fieldDesc)) {
                    kf_statusFieldName = formFieldBean.getName();
                }
            }
            // 根据已确定的条件构建SQL查询语句
            StringBuilder stb = new StringBuilder();
            stb.append("select ");
            if (!"".equals(jhks_dateTimeFieldName)) {
                stb.append(jhks_dateTimeFieldName).append(",");
            }
            if (!"".equals(subSjwcDateTimeFieldName)) {
                stb.append(subSjwcDateTimeFieldName).append(",");
            }
            if (!"".equals(kf_statusFieldName)) {
                stb.append(kf_statusFieldName).append(",");
            }
            if (!"".equals(lcbFieldName) && !"".equals(tableName) && !"".equals(lcbztFieldName)) {
                stb.append(lcbztFieldName).append(" from ").append(tableName);
                stb.append(" where ").append(lcbFieldName).append(" = '").append(ctpEnumItem.getId()).append("' and ").append(isLcbFieldName).append(" = '").append(qxEnum_sfS.getId()).append("'");

            }
            // 日志记录构建的SQL查询语句
            log.info("管理模块sql:" + stb.toString());
            // 执行SQL查询并统计结果
            List list = capDataListSqlHelpManager.selectDataList(stb.toString(), null);
            int sum = list.size();
            //有时间的数量
            int timeSum = 0;
            sumNumber += sum;
            if (!list.isEmpty()) {
                for (int i = 0; i < list.size(); i++) {
                    Map<String, Object> dataMap = (Map<String, Object>) list.get(i);
                    Object jhks_dateTimeValue = dataMap.get(jhks_dateTimeFieldName);
                    Object subSjwcDateTimeValue = dataMap.get(subSjwcDateTimeFieldName);
                    if (!"".equals(StrKit.str(jhks_dateTimeValue)) && !"".equals(StrKit.str(subSjwcDateTimeValue))) {
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date jhks_dateTimeValue_new = sdf.parse(jhks_dateTimeValue.toString());
                        Date subSjwcDateTimeValue_new = sdf.parse(subSjwcDateTimeValue.toString());
                        long sjc = subSjwcDateTimeValue_new.getTime() - jhks_dateTimeValue_new.getTime();
                        pjsc += sjc;
                        timeSum += 1;
                    }
                    String lcbzt = StrKit.str(dataMap.get(lcbztFieldName));
                    String kfzt = StrKit.str(dataMap.get(kf_statusFieldName));
                    if (!"".equals(lcbzt)) {
                        CtpEnumItem lcbStatusEnum = enumManager.getCtpEnumItem(Long.parseLong(lcbzt));
                        String enumItemCode = StrKit.str(lcbStatusEnum.getEnumItemCode());
                        CtpEnumItem kfStatusEnum = enumManager.getCtpEnumItem(Long.parseLong(kfzt));
                        String kfEnumItemCode = StrKit.str(kfStatusEnum.getEnumItemCode());
                        // 根据不同的状态码进行数量统计
                        /*总未完成数量  里程碑状态不等于已完成*/
                        if (!"LCBZT_YWC".equals(enumItemCode) && !"KFZT_GBQX".equals(kfEnumItemCode) && !"KFZT_YWC".equals(kfEnumItemCode)) {
                            wwcSum += 1;
                        }
                        /*方案输出  里程碑状态不等于已完成且不等于PTD评审*/
                        if (!"LCBZT_YWC".equals(enumItemCode) && !"LCBZT_PS".equals(enumItemCode) && !"KFZT_GBQX".equals(kfEnumItemCode) && !"KFZT_YWC".equals(kfEnumItemCode)) {
                            fascSum += 1;
                        }
                        /*推品评审  里程碑状等于PTD评审*/
                        if ("LCBZT_PS".equals(enumItemCode) && !"KFZT_GBQX".equals(kfEnumItemCode)  && !"KFZT_YWC".equals(kfEnumItemCode)) {
                            tppsSum += 1;
                        }
                    }
                }
            }

            // 组装最终的结果数据
            /*总需求数*/
            Map<String, Object> sumMap = new HashMap<String, Object>();
            sumMap.put("num", sumNumber);
            //组装跳转地址
            if ("LCB_TP".equals(type)) {
                sumMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_tpgl_zxqs")));
            } else if ("LCB_SJ".equals(type)) {
                sumMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_sjgl_zxqs")));
            } else if ("LCB_DY".equals(type)) {
                sumMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_dygl_zxqs")));
            } else if ("LCB_ZB".equals(type)) {
                sumMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_zbgl_zxqs")));
            }
            resultDataMap.put("sum", sumMap);
            /*总未完成数量*/
            Map<String, Object> wwcMap = new HashMap<String, Object>();
            wwcMap.put("num", wwcSum);
            if ("LCB_TP".equals(type)) {
                wwcMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_tpgl_zwwc")));
            } else if ("LCB_SJ".equals(type)) {
                wwcMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_sjgl_zwwc")));
            } else if ("LCB_DY".equals(type)) {
                wwcMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_dygl_zwwc")));
            } else if ("LCB_ZB".equals(type)) {
                wwcMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_zbgl_zwwc")));
            }
            resultDataMap.put("wwc", wwcMap);
            /*方案输出、样品输出、标书输出*/
            Map<String, Object> fascMap = new HashMap<String, Object>();
            fascMap.put("num", fascSum);
            if ("LCB_TP".equals(type)) {
                fascMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_tpgl_fasc")));
            } else if ("LCB_SJ".equals(type)) {
                fascMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_sjgl_fasc")));
            } else if ("LCB_DY".equals(type)) {
                fascMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_dygl_ypsc")));
            } else if ("LCB_ZB".equals(type)) {
                fascMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_zbgl_bssc")));
            }
            resultDataMap.put("tpjj", fascMap);
            /*推品、设计、样品评审*/
            Map<String, Object> tppsMap = new HashMap<String, Object>();
            tppsMap.put("num", tppsSum);
            if ("LCB_TP".equals(type)) {
                tppsMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_tpgl_tpps")));
            } else if ("LCB_SJ".equals(type)) {
                tppsMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_sjgl_sjps")));
            } else if ("LCB_DY".equals(type)) {
                tppsMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_dygl_ypps")));
            } else if ("LCB_ZB".equals(type)) {
                tppsMap.put("url", "");
            }
            resultDataMap.put("tpps", tppsMap);
            log.info("pjsc==="+pjsc);
            log.info("timeSum==="+timeSum);
            Double pjscValue = 0.0;
            if (timeSum != 0) {
                double averageMilliseconds = (double) pjsc / timeSum;
                double averageDays = averageMilliseconds / (1000 * 60 * 60 * 24);
                DecimalFormat df = new DecimalFormat("#.0");
                pjscValue = Double.parseDouble(df.format(averageDays));
            }else {
                pjscValue = 0.0;
            }
            log.info("pjscValue==="+pjscValue);

//            String pjscValue = StrKit.convertMinuteToHM(diffMinutes);
            resultDataMap.put("pjsc", pjscValue+"天");
            // 设置结果映射中的数据并返回
            result.put("code", 200);
            result.put("data", resultDataMap);
            result.put("msg", "");
            return ok(JSON.toJSONString(result));
        } catch (Exception e) {
            // 记录查询过程中的异常
            log.error("获取推品设计打样制标管理模块数据错误:", e);
            // 在出现异常时，返回包含错误信息的结果
            result.put("code", 500);
            result.put("data", "");
            result.put("msg", e.getMessage());
            return ok(JSON.toJSONString(result));
        }
    }

    /**
     * 通过POST请求处理IPD需求管理数据的接口。
     *
     * @param param 请求参数，作为一个Map接收，包含各种查询条件。
     * @return 返回处理结果，包括状态码、数据和消息。
     * @throws Exception 如果处理过程中发生异常。
     */
    @POST
    @Path("ipd/requirement/manage/data")
    public Response ipdRequirementManageData(Map<String, Object> param) throws Exception {
        // 初始化结果映射，用于组装返回的数据。
        Map<String, Object> result = new HashMap<String, Object>();
        try {
            // 获取《新IPD-需求分析与分发》表单编号
            String xipd_xqfxyff_formCode = AppContext.getSystemProperty("kanban.xipd_xqfxyff_formCode");
            // 获取《研发项目档案》表单编号
            String yfxmda_formCode = AppContext.getSystemProperty("kanban.yfxmda_formCode");
            //新IPD接收时间、处理时间
            String xipd_receive_time = AppContext.getSystemProperty("kanban.xipd_receive_time");
            String xipd_process_time = AppContext.getSystemProperty("kanban.xipd_process_time");

            //研发项目档案开发状态
            String kf_status = AppContext.getSystemProperty("kanban.kfStatus");
            //开发状态-关闭取消
            String kfzt_gbqx = AppContext.getSystemProperty("kanban.kfzt_gb");
            CtpEnumItem gbqxEnum = FormCap4Kit.getEnumByCode(kfzt_gbqx);


            // 根据编码获取表单
            FormBean xipd_xqfxyff_formBean = cap4FormManager.getFormByFormCode(xipd_xqfxyff_formCode);
            FormBean yfxmda_formBean = cap4FormManager.getFormByFormCode(yfxmda_formCode);

            // 如果表单配置不存在，则返回错误信息。
            if (xipd_xqfxyff_formBean == null) {
                result.put("code", 500);
                result.put("data", "");
                result.put("msg", "新IPD-需求分析与分发表单编码【XIPD_XQFXYFF_001】未维护!");
                return ok(JSON.toJSONString(result));
            }

            if (yfxmda_formBean == null) {
                result.put("code", 500);
                result.put("data", "");
                result.put("msg", "研发项目档案表单编码【YFXMDA_001】未维护!");
                return ok(JSON.toJSONString(result));
            }

            // 从表单配置中获取相关字段的名称，用于构建SQL查询语句。
            List<FormFieldBean> xipd_xqfxyff_formFieldBeans =xipd_xqfxyff_formBean.getAllFieldBeans();
            String jsDateTimeFieldName = "";
            String clDateTimeFieldName = "";
            for (FormFieldBean formFieldBean:xipd_xqfxyff_formFieldBeans) {
                String fieldDesc = StrKit.str(formFieldBean.getDesc().trim());
                if (xipd_receive_time.equals(fieldDesc)) {
                    jsDateTimeFieldName = formFieldBean.getName();
                }
                if (xipd_process_time.equals(fieldDesc)) {
                    clDateTimeFieldName = formFieldBean.getName();
                }
            }
            //《新IPD-需求分析与分发》数据库表名
            String tableName = xipd_xqfxyff_formBean.getMasterTableBean().getTableName();
            // 构建SQL查询语句，查询平均处理时间。
            StringBuilder stb = new StringBuilder();
            stb.append("select ").append(jsDateTimeFieldName).append(", ");
            stb.append(clDateTimeFieldName).append(" from ").append(tableName);

            // 记录查询的SQL语句，用于日志记录。
            log.info("查询IPD需求管理的平均处理时长sql:" + stb.toString());
            // 执行查询，并获取结果列表。
            List list = capDataListSqlHelpManager.selectDataList(stb.toString(), null);

            //计算平均处理时长条数
            int jsSum = 0;
            long pjsc = 0;
            // 遍历查询结果，进行数量统计和处理时间计算。
            if (!list.isEmpty()) {
                for (int i = 0; i < list.size(); i++) {
                    Map<String, Object> dataMap = (Map<String, Object>) list.get(i);
                    Object jsDateTime = dataMap.get(jsDateTimeFieldName);
                    Object clDateTime = dataMap.get(clDateTimeFieldName);
                    // 如果接收时间和处理时间都存在，则计算处理时间差，并累加到总处理时间差。
                    if (!"".equals(StrKit.str(jsDateTime)) && !"".equals(StrKit.str(clDateTime))) {
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                        Date jhks_dateTimeValue_new = sdf.parse(jsDateTime.toString());
                        Date subSjwcDateTimeValue_new = sdf.parse(clDateTime.toString());
                        long sjc = subSjwcDateTimeValue_new.getTime() - jhks_dateTimeValue_new.getTime();
                        pjsc += sjc;
                        jsSum += 1;

                    }

                }
            }
            //获取研发项目档案表名，开发状态字段名
            String yfxmTableName = yfxmda_formBean.getMasterTableBean().getTableName();
            List<FormFieldBean> yfxm_formFieldBeans =yfxmda_formBean.getAllFieldBeans();
            String kfztFieldName = "";
            for (FormFieldBean formFieldBean:yfxm_formFieldBeans) {
                String fieldDesc = StrKit.str(formFieldBean.getDesc().trim());
                if (kf_status.equals(fieldDesc)) {
                    kfztFieldName = formFieldBean.getName();
                }
            }

            // 构建SQL查询语句，查询需求管理信息。
            StringBuilder xqglStb = new StringBuilder();
            xqglStb.append("select ").append(kfztFieldName).append(" from ").append(yfxmTableName);

            // 记录查询的SQL语句，用于日志记录。
            log.info("查询IPD需求管理数据sql:" + xqglStb.toString());

            // 执行查询，并获取结果列表。
            List xqglList = capDataListSqlHelpManager.selectDataList(xqglStb.toString(), null);
            //未完成(不等于已完成)
            int wwcSum = 0;
            //计划评审(不等于已完成、不等于PTD评审)
            int jhpsSum = 0;
            //方案评审(等于PTD评审)
            int fapsSum = 0;

            // 遍历查询结果，进行数量统计和处理时间计算。
            if (!xqglList.isEmpty()) {
                for (int i = 0; i < xqglList.size(); i++) {
                    Map<String, Object> dataMap = (Map<String, Object>) xqglList.get(i);
                    String kfzt = StrKit.str(dataMap.get(kfztFieldName));
                    // 根据开发状态进行不同的数量统计。
                    if (!"".equals(kfzt)) {
                        CtpEnumItem lcbStatusEnum = enumManager.getCtpEnumItem(Long.parseLong(kfzt));
                        String enumItemCode = StrKit.str(lcbStatusEnum.getEnumItemCode());
                        // 总未完成数量的统计条件。
                        if (!"KFZT_YWC".equals(enumItemCode) && !"KFZT_GBQX".equals(enumItemCode)  ) {
                            wwcSum += 1;
                        }
                        // 计划评审数量的统计条件。
                        if (!"KFZT_YWC".equals(enumItemCode) && !"KFZT_PS".equals(enumItemCode) && !"KFZT_GBQX".equals(enumItemCode) ) {
                            jhpsSum += 1;
                        }
                        // 方案评审的统计条件。
                        if ("KFZT_PS".equals(enumItemCode)) {
                            fapsSum += 1;
                        }
                    }
                }
            }


            // 组装统计数据的结果映射。
            Map<String, Object> resultDataMap = new HashMap<String, Object>();
            int sumNumber = xqglList.size();
            /*总需求数*/
            Map<String, Object> sumMap = new HashMap<String, Object>();
            sumMap.put("num", sumNumber);
            sumMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_xqgl_zxqs")));
            resultDataMap.put("sum", sumMap);
            /*总未完成数量*/
            Map<String, Object> wwcMap = new HashMap<String, Object>();
            wwcMap.put("num", wwcSum);
            wwcMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_xqgl_zwwc")));
            resultDataMap.put("wwc", wwcMap);
            /*计划评审*/
            Map<String, Object> jhpsMap = new HashMap<String, Object>();
            jhpsMap.put("num", jhpsSum);
            jhpsMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_xqgl_jhps")));
            resultDataMap.put("tpjj", jhpsMap);
            /*方案评审*/
            Map<String, Object> fapsMap = new HashMap<String, Object>();
            fapsMap.put("num", fapsSum);
            fapsMap.put("url", FormCap4Kit.getBbAddres(AppContext.getSystemProperty("kanban.ipd_xqgl_faps")));
            resultDataMap.put("tpps", fapsMap);
            // 计算处理时间差的分钟数，并转换为分钟:秒的格式。
            long diffMinutes = pjsc / (60 * 1000);
            String pjscValue = "";
            if (jsSum != 0){
                pjscValue = StrKit.convertMinuteToHM(diffMinutes/jsSum);
            }else {
                pjscValue = "0";
            }

            resultDataMap.put("pjsc", pjscValue);
            // 设置结果映射中的数据，并返回成功响应。
            result.put("code", 200);
            result.put("data", resultDataMap);
            result.put("msg", "");
            return ok(JSON.toJSONString(result));
        } catch (Exception e) {
            // 如果处理过程中发生异常，则记录错误日志，并返回错误响应。
            log.error("获取IPD需求管理数据错误:", e);
            result.put("code", 500);
            result.put("data", "");
            result.put("msg", e.getMessage());
            return ok(JSON.toJSONString(result));
        }
    }

    /**
     * 获取IPD预警指标数据的接口。
     * 该方法通过接收一个包含参数的Map对象，返回IPD预警指标的相关数据。
     * 主要包括推品、设计、打样、制标预警指标和项目预警指标的数据。
     *
     * @param param 包含请求参数的Map对象。
     * @return 包含预警指标数据的Response对象。
     * @throws Exception 如果发生异常，会抛出Exception。
     */
    @POST
    @Path("ipd/early/warning/index/data")
    public Response ipdEarlyWarningIndexData(Map<String, Object> param) throws Exception {
        Map<String,Object> result=new HashMap<>();
        result.put("code", 200);
        result.put("data", ipdKanBanDataManager.getyjxx());
        result.put("msg", "");
        return this.ok(JSON.toJSONString(result));
    }


    /**
     * 获取资源池使用情况的数据。
     * 该方法通过调用ipdKanBanDataManager的getzycsyqkCount方法来获取资源池的使用情况统计，
     * 并将结果封装到一个Map中返回给调用者。如果在获取数据的过程中发生异常，
     * 则会返回一个包含错误信息的Map。
     *
     * @param param 传递给后台的参数，本方法中未使用。
     * @return 包含资源池使用情况数据的Map。
     * @throws Exception 如果获取数据过程中发生异常，则抛出此异常。
     */
    @POST
    @Path("ipd/Resource/pool/usage/situation")
    public Response ipdResourcePoolData(Map<String, Object> param) throws Exception {
        // 初始化结果Map，用于存放返回的数据。
        Map<String, Object> result = new HashMap<String, Object>();
        try {
            // 调用ipdKanBanDataManager的getzycsyqkCount方法获取资源池使用情况数据。
            Map<String, Object> dataMap = ipdKanBanDataManager.getzycsyqkCount();
            Map<String, Object> wwcDataMap = new HashMap<String, Object>();
            if (dataMap.containsKey("cpjl")) {
                Map<String, Object> cpjlMap = (Map<String, Object>) dataMap.get("cpjl");
                for (Map.Entry<String, Object> entry : cpjlMap.entrySet()) {
                    String key = entry.getKey();
                    Map<String, Object> value = (Map<String, Object>) entry.getValue();
                    Map<String, Object> wwcMap = new HashMap<String, Object>();
                    wwcMap.put("cpjlNum", value.get("wwcNum"));
                    wwcDataMap.put(key, wwcMap);
                }
            }
            if (dataMap.containsKey("dy")) {
                Map<String, Object> dyMap = (Map<String, Object>) dataMap.get("dy");
                for (Map.Entry<String, Object> entry : dyMap.entrySet()) {
                    String key = entry.getKey();
                    Map<String, Object> value = (Map<String, Object>) entry.getValue();
                    if (wwcDataMap.containsKey(key)) {
                        Map<String, Object> map = (Map<String, Object>) wwcDataMap.get(key);
                        map.put("dyNum", value.get("wwcNum"));
                        wwcDataMap.put(key, map);
                    } else {

                        Map<String, Object> wwcMap = new HashMap<String, Object>();
                        wwcMap.put("dyNum", value.get("wwcNum"));
                        wwcDataMap.put(key, wwcMap);
                    }
                }
            }
            if (dataMap.containsKey("sj")) {
                Map<String, Object> sjMap = (Map<String, Object>) dataMap.get("sj");
                for (Map.Entry<String, Object> entry : sjMap.entrySet()) {
                    String key = entry.getKey();
                    Map<String, Object> value = (Map<String, Object>) entry.getValue();
                    if (wwcDataMap.containsKey(key)) {
                        Map<String, Object> map = (Map<String, Object>) wwcDataMap.get(key);
                        map.put("sjNum", value.get("wwcNum"));
                        wwcDataMap.put(key, map);
                    } else {
                        Map<String, Object> wwcMap = new HashMap<String, Object>();
                        wwcMap.put("sjNum", value.get("wwcNum"));
                        wwcDataMap.put(key, wwcMap);
                    }
                }
            }
            if (dataMap.containsKey("tp")) {
                Map<String, Object> tpMap = (Map<String, Object>) dataMap.get("tp");
                for (Map.Entry<String, Object> entry : tpMap.entrySet()) {
                    String key = entry.getKey();
                    Map<String, Object> value = (Map<String, Object>) entry.getValue();
                    if (wwcDataMap.containsKey(key)) {
                        Map<String, Object> map = (Map<String, Object>) wwcDataMap.get(key);
                        map.put("tpNum", value.get("wwcNum"));
                        wwcDataMap.put(key, map);
                    } else {
                        Map<String, Object> wwcMap = new HashMap<String, Object>();
                        wwcMap.put("tpNum", value.get("wwcNum"));
                        wwcDataMap.put(key, wwcMap);
                    }
                }
            }
            if (dataMap.containsKey("zb")) {
                Map<String, Object> zbMap = (Map<String, Object>) dataMap.get("zb");
                for (Map.Entry<String, Object> entry : zbMap.entrySet()) {
                    String key = entry.getKey();
                    Map<String, Object> value = (Map<String, Object>) entry.getValue();
                    if (wwcDataMap.containsKey(key)) {
                        Map<String, Object> map = (Map<String, Object>) wwcDataMap.get(key);
                        map.put("zbNum", value.get("wwcNum"));
                        wwcDataMap.put(key, map);
                    } else {
                        Map<String, Object> wwcMap = new HashMap<String, Object>();
                        wwcMap.put("zbNum", value.get("wwcNum"));
                        wwcDataMap.put(key, wwcMap);
                    }
                }
            }
            dataMap.put("wwcNumXqlb", wwcDataMap);
            // 将成功代码、数据和空消息放入结果Map。
            result.put("code", 200);
            result.put("data", dataMap);
            result.put("msg", "");
            // 返回处理好的数据。
            return ok(JSON.toJSONString(result));
        } catch (Exception e) {
            // 如果发生异常，记录错误日志，并将错误代码、空数据和错误消息放入结果Map。
            log.error("获取资源池数据错误:", e);
            result.put("code", 500);
            result.put("data", "");
            result.put("msg", e.getMessage());
            // 返回包含错误信息的处理结果。
            return ok(JSON.toJSONString(result));
        }
    }

    /**
     * 通过POST请求获取IPD项目信息数据。
     *
     * @param param 一个Map对象，包含项目名称、开始时间和结束时间等参数。
     * @return 返回一个Response对象，其中包含请求的结果信息。
     * @throws Exception 如果发生业务异常，则抛出异常。
     * @Path("ipd/project/info/datas") 注解指定了RESTful API的路径。
     * @POST 注解指定了使用POST方法。
     */
    @POST
    @Path("ipd/project/info/datas")
    public Response ipdProjectInfoData(Map<String, Object> param) throws Exception {
        // 记录请求参数的日志信息。
        log.info("项目信息模块前端入参:" + JSON.toJSONString(param));
        Map<String, Object> result = new HashMap<String, Object>();
        List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();
        try {
            // 从param Map中提取项目名称、开始时间和结束时间。
            JSONObject jsonObject = new JSONObject(param);
            String projectName = "";
            if (jsonObject.containsKey("projectName")) {
                projectName = StrKit.str(jsonObject.get("projectName"));
            }
            String startTime = "";
            if (jsonObject.containsKey("startTime")) {
                startTime = StrKit.str(jsonObject.get("startTime"));
            }
            String endTime = "";
            if (jsonObject.containsKey("endTime")) {
                endTime = StrKit.str(jsonObject.get("endTime"));
            }
            String projectCode = "";
            if (jsonObject.containsKey("projectCode")) {
                projectCode = StrKit.str(jsonObject.get("projectCode"));
            }
            String level= "";
            if (jsonObject.containsKey("level")) {
                level = StrKit.str(jsonObject.get("level"));
            }
            String status= "";
            if (jsonObject.containsKey("status")) {
                status = StrKit.str(jsonObject.get("status"));
            }
            String comeSource= "";
            if (jsonObject.containsKey("comeSource")) {
                comeSource = StrKit.str(jsonObject.get("status"));
            }
            String proManagerName= "";
            if (jsonObject.containsKey("proManagerName")) {
                proManagerName = StrKit.str(jsonObject.get("proManagerName"));
            }
            String cusManagerName= "";
            if (jsonObject.containsKey("cusManagerName")) {
                cusManagerName = StrKit.str(jsonObject.get("cusManagerName"));
            }
            String productsManagerName= "";
            if (jsonObject.containsKey("productsManagerName")) {
                productsManagerName = StrKit.str(jsonObject.get("productsManagerName"));
            }

            // 根据项目名称、开始时间和结束时间，从数据库中查询项目信息数据列表。
            dataList = ipdKanBanDataManager.getProjectInfoDataList( projectName,  startTime,  endTime, projectCode,  level, status, comeSource, proManagerName, cusManagerName,  productsManagerName);
            // 设置返回结果的代码、数据和消息字段。
            result.put("code", 200);
            result.put("data", dataList);
            result.put("msg", "");
            return ok(JSON.toJSONString(result));
        } catch (BusinessException e) {
            // 记录业务异常的日志信息。
            log.error("获取项目信息模块数据报错异常信息:", e);
            // 设置返回结果的错误代码、空数据和错误消息。
            result.put("code", 500);
            result.put("data", "");
            result.put("msg", e.getMessage());
            return ok(JSON.toJSONString(result));
        }
    }
}
